package com.orangelife.mobile.voucher.biz;

import com.curry.android.util.StringUtil;
import com.orangelife.mobile.util.ToastHelper;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;

/**
 * 已选中的抵用券列表MAP的维护类
 * Created by wgf on 2016/3/7.
 */
public class SelectedVoucherIDListHelper {

    private static SelectedVoucherIDListHelper helper;
    private String totalSelectedVoucherPrice;
    private String mVoucherListMapKey;

    /** 维护所选中的抵用券列表的map，Map<VoucherListKey,VoucherList>，多选模式时是列表，单选模式时列表只有一个元素 */
    private HashMap<String, ArrayList<String>> selectedVouchersIDListMap = new HashMap<>();

    private SelectedVoucherIDListHelper() {

    }

    /**
     * 这里为什么使用单例来维护这个MAP呢？因为这个MAP要被A界面传到其Adapter，再跳转到B界面，再传回A，
     * 过程太长，虽然单例的缺点是全局存在，但是极大简化了对MAP的处理和传递，可以接受
     */
    public static SelectedVoucherIDListHelper getInstance() {
        if (helper == null) {
            helper = new SelectedVoucherIDListHelper();
        }
        return helper;
    }

    public void setTotalSelectedVoucherPrice(String totalSelectedVoucherPrice) {
        this.totalSelectedVoucherPrice = totalSelectedVoucherPrice;
    }

    public String getTotalSelectedVoucherPrice() {
        return this.totalSelectedVoucherPrice;
    }

    public String getVoucherListMapKey() {
        return mVoucherListMapKey;
    }

    //这是已选中抵用券列表的KEY，注意，之所以会出现MAP存储LIST，
    // 这种形式，因为商户列表的存在，其他都是只有一个抵用券列表，但还是有KEY，取LIST；
    /*必须注释：这说明来是自周边商品（有多个商户，以商户ID为KEY）;而不是来自单个商品，如DD洗车（以商品ID为KEY）和维修（无KEY），只有一个商户*/
    public void setVoucherListMapKey(String voucherListMapKey) {
        this.mVoucherListMapKey = voucherListMapKey;
    }

    public HashMap<String, ArrayList<String>> getSelectedVouchersIDListMap() {
        return selectedVouchersIDListMap;
    }

    public ArrayList<String> getOtherVoucherList() {
        return getOtherVoucherList(mVoucherListMapKey);
    }

    /**
     * 其他商户已选择抵用券ID(在本商户/商品的抵用券列表中可选其他商户/商品的抵用券，影响其他商户/商品抵用券列表时，会用到此方法)
     *
     * @param currentMerID 当前商户的ID
     * @return
     */
    public ArrayList<String> getOtherVoucherList(String currentMerID) {
        ArrayList<String> otherVoucherList = new ArrayList<>();
        for (String keyMerID : selectedVouchersIDListMap.keySet()) {
            if (!keyMerID.equals(currentMerID)) {
                ArrayList<String> voucherList = selectedVouchersIDListMap.get(keyMerID);
                for (int i = 0; i < voucherList.size(); i++) {/*这个算法显然是不够好的*/
                    otherVoucherList.add(voucherList.get(i));
                }
            }
        }
        return otherVoucherList;
    }

    /**
     * 当前商户已选择抵用券
     * <p/>
     * 商户、商品（包括洗车、停车卡、物业费）、在商户列表中使用抵用券时，存在多个商户的各自的抵用券列表，此时用商户ID作为各个列表的KEY。单个商品使用抵用券（如洗车、停车卡、缴费），只有一个抵用券列表，使用其各自的ID作为KEY。（多选模式存在抵用券列表，单选模式只存在一张抵用券）
     *
     * @return
     */
    public ArrayList<String> getSelfVoucherList() {
        return getSelfVoucherListWithKey(mVoucherListMapKey);
    }

    public ArrayList<String> getSelfVoucherListWithKey(String voucherListMapKey) {
        if (!StringUtil.isBlank(voucherListMapKey)) {
            return selectedVouchersIDListMap.get(voucherListMapKey);
        } else {
            return getVoucherIDListWithNoKey();
        }
    }

    /** 单商品模式，只有一个商品存在，则无KEY */
    public ArrayList<String> getVoucherIDListWithNoKey() {
        if (selectedVouchersIDListMap != null && selectedVouchersIDListMap.size() == 1) {
            for (String key : selectedVouchersIDListMap.keySet()) {
                return selectedVouchersIDListMap.get(key);
            }
        }
        ArrayList<String> list = new ArrayList<>();
        return list;
    }

    /**
     * 该商户是否有选中此抵用券，通过抵用券ID
     */
    public boolean isExistThisVoucherInMerchant(String voucherID) {
        ArrayList<String> selfVoucherList = getSelfVoucherList();
        for (int i = 0; i < selfVoucherList.size(); i++) {
            if (selfVoucherList.get(i).equals(voucherID)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 更新此商户已选中的抵用券列表
     *
     * @param newSelectedVoucherIDList 新的已选中的抵用券列表
     * @param merID                    商户ID
     */
    public void updateSelectedVoucherIDList(ArrayList<String> newSelectedVoucherIDList, String merID) {
        for (String keyMerID : selectedVouchersIDListMap.keySet()) {
            if (keyMerID.equals(merID)) {
                ArrayList<String> oldSelectedVoucherIDList = selectedVouchersIDListMap.get(keyMerID);
                oldSelectedVoucherIDList.clear();
                oldSelectedVoucherIDList.addAll(newSelectedVoucherIDList);
            }
        }
    }

    /** 更新当前商户/商品的已选择抵用券列表，因为在调用类已经初始化了 */
    public void updateCurrentSelectedVoucherIDList(ArrayList<String> newSelectedVoucherIDList) {
        updateSelectedVoucherIDList(newSelectedVoucherIDList, mVoucherListMapKey);
    }

    public void addSelectedVoucherID(String voucherID, String voucherListKey) {
        addSelectedVoucherID(voucherID,voucherListKey,false);
    }

    /**
     * 添加此商户已选中的抵用券到对应的商户map
     */
    public void addSelectedVoucherID(String voucherID, String voucherListKey, boolean isSingleMode) {
        //首先判断商户ID是否存在，然后判断抵用券ID是否存在，不存在则添加
        boolean hasExistMerchant = false;
        for (String key : selectedVouchersIDListMap.keySet()) {
            if (key.equals(voucherListKey)) {
                hasExistMerchant = true;
                ArrayList<String> voucherIDList = selectedVouchersIDListMap.get(key);
                boolean hasExist = false;
                for (int i = 0; i < voucherIDList.size(); i++) {
                    String savedCouponID = voucherIDList.get(i);
                    if (savedCouponID.equals(voucherID)) {
                        hasExist = true;
                        break;
                    }
                }
                if (!hasExist) {
                    if (isSingleMode) {/*如果是单选模式，则需要清除原有选中的数据，否则会出现多选现象*/
                        voucherIDList.clear();
                    }
                    voucherIDList.add(voucherID);
                }
                break;
            }
        }
        if (!hasExistMerchant) {
            ArrayList<String> list = new ArrayList<>();
            list.add(voucherID);
            selectedVouchersIDListMap.put(voucherListKey, list);
        }
    }

    /**
     * 取消选中抵用券
     */
    public void deleteVoucherID(String couponID) {

    }

    /***/
    private void clearMap() {
        if (selectedVouchersIDListMap != null) {
            selectedVouchersIDListMap.clear();
        }
    }

    /**
     * 只是借用单例模式传值，使用结束后销毁
     */
    public void destroyBiz() {
        clearMap();
        helper = null;
    }


    /** 多选模式:重置选中抵用券列表的叠加状态 */
    public void resetVoucherSuperPositionStatus() {
        hasOnlyOnePlatform = false;
        hasOnlyOneMerchant = false;
        moreMerchantType = "";
        if (platformMoreVoucherIDList != null) {
            platformMoreVoucherIDList.clear();
        }
        if (merchantMoreVoucherIDList != null) {
            merchantMoreVoucherIDList.clear();
        }
    }

    /**
     * 多选模式：判断叠加状态，在用户取消抵用券后，改变叠加状态
     */
    public void updateVoucherSuperPositionStatusWhenCancel(String type, String voucherID) {
        if (hasOnlyOnePlatform) {//唯一平台不可叠加
            ToastHelper.getInstance()._toast("唯一平台不可叠加 取消");
            hasOnlyOnePlatform = false;
        } else if (hasOnlyOneMerchant) {//唯一商户不可叠加
            ToastHelper.getInstance()._toast("唯一商户不可叠加 取消");
            hasOnlyOneMerchant = false;
        } else {
            if (type.equals(VOUCHER_TYPE_PLATFORM)) {
                ToastHelper.getInstance()._toast("平台可叠加 取消一个");
                platformMoreVoucherIDList.remove(voucherID);
            } else {
                ToastHelper.getInstance()._toast("商户可叠加 取消一个");
                merchantMoreVoucherIDList.remove(voucherID);
                if (merchantMoreVoucherIDList.size() == 0) {
                    ToastHelper.getInstance()._toast("商户可叠加 全部取消");
                    moreMerchantType = "";
                }
            }
        }
    }

    /**
     * 多选模式：判断叠加状态，但凡是有抵用券列表的，必有一张默认选中的
     *
     * @param type      平台、非平台
     * @param useType   是否可叠加
     * @param voucherID 抵用券ID
     * @return
     */
    public synchronized boolean checkVoucherSuperPositionStatusWhenSelecting(String type, String useType, String voucherID) {
        if (type.equals(VOUCHER_TYPE_PLATFORM)) {//是平台
            if (!hasOnlyOnePlatform) {//目前状态不是不可叠加
                if (useType.equals(VOUCHER_USE_TYPE_ENABLE)) {//新增的是可叠加
                    platformMoreVoucherIDList.add(voucherID);
                    ToastHelper.getInstance()._toast("新增一张可叠加平台抵用券");
                    return true;
                } else {
                    if (platformMoreVoucherIDList.size() == 0) {
                        hasOnlyOnePlatform = true;
                        ToastHelper.getInstance()._toast("新增第一张不可叠加平台抵用券");
                        return true;
                    } else {
                        ToastHelper.getInstance()._toast("已存在一张可叠加的平台抵用券，不能再叠加使用不可叠加的平台抵用券");
                    }
                }
            } else {
                ToastHelper.getInstance()._toast("已存在一张不可叠加的平台抵用券，不能再叠加使用任何平台抵用券");
            }
        } else {//不是平台
            if (!hasOnlyOneMerchant) {//目前状态不是不可叠加
                if (useType.equals(VOUCHER_USE_TYPE_ENABLE)) {//非平台、可叠加、类型相同
                    if (merchantMoreVoucherIDList.size() == 0) {
                        moreMerchantType = type;
                        merchantMoreVoucherIDList.add(voucherID);
                        ToastHelper.getInstance()._toast("新增第一张可叠加商户抵用券");
                        return true;
                    } else {
                        if (moreMerchantType.equals(type)) {
                            merchantMoreVoucherIDList.add(voucherID);
                            ToastHelper.getInstance()._toast("新增一张类型相同的可叠加商户抵用券");
                            return true;
                        } else {
                            ToastHelper.getInstance()._toast("已存在一张不同类型的可叠加商户抵用券，不能再叠加使用其他类型的可叠加商户抵用券");
                        }
                    }

                } else {
                    if (merchantMoreVoucherIDList.size() == 0) {
                        hasOnlyOneMerchant = true;
                        ToastHelper.getInstance()._toast("新增第一张不可叠加商户抵用券");
                        return true;
                    } else {
                        ToastHelper.getInstance()._toast("已存在一张可叠加的商家抵用券，不能再叠加使用不可叠加商家抵用券");
                    }
                }
            } else {
                ToastHelper.getInstance()._toast("已存在一张不可叠加的商家抵用券，不能再叠加使用任何商家抵用券");
            }
        }
        //hasOnly?
        //yes,break;
        //no,add to list;
        //else merchant
        //hasOnly?
        //yes break
        //else
        //if equal?
        //yes,add add to list
        //else break;
        return false;
    }

    /**
     * 多选模式：只有一张不可叠加的平台抵用券
     */
    private boolean hasOnlyOnePlatform = false;
    /**
     * 多选模式：只有一张不可叠加的商户抵用券
     */
    private boolean hasOnlyOneMerchant = false;
    /**
     * 多选模式：当前可叠加同类型抵用券的类型
     */
    private String moreMerchantType = "";
    /**
     * 多选模式：可叠加的平台抵用券列表
     */
    private LinkedList<String> platformMoreVoucherIDList = new LinkedList<>();
    /**
     * 多选模式：可叠加的同类型的商户抵用券列表
     */
    private LinkedList<String> merchantMoreVoucherIDList = new LinkedList<>();

    /**
     * 多选模式：抵用券类型，全平台通用
     */
    public static String VOUCHER_TYPE_PLATFORM = "0";
    /**
     * 多选模式：抵用券类型，特定商户使用
     */
    public static String VOUCHER_TYPE_MECHANT = "1";
    /**
     * 多选模式：同类型抵用券不可叠加使用
     */
    public static String VOUCHER_USE_TYPE_ENABLE = "0";
    /**
     * 多选模式：同类型抵用券可叠加使用
     */
    public static String VOUCHER_USE_TYPE_DISABLE = "1";
}
